package sk.scerbak.ucl.common.parser.antlr.internal; 

import org.eclipse.xtext.*;
import org.eclipse.xtext.parser.*;
import org.eclipse.xtext.parser.impl.*;
import org.eclipse.emf.ecore.util.EcoreUtil;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.xtext.parser.antlr.AbstractInternalAntlrParser;
import org.eclipse.xtext.parser.antlr.XtextTokenStream;
import org.eclipse.xtext.parser.antlr.XtextTokenStream.HiddenTokens;
import org.eclipse.xtext.parser.antlr.AntlrDatatypeRuleToken;
import sk.scerbak.ucl.common.services.CommonGrammarAccess;



import org.antlr.runtime.*;
import java.util.Stack;
import java.util.List;
import java.util.ArrayList;

@SuppressWarnings("all")
public class InternalCommonParser extends AbstractInternalAntlrParser {
    public static final String[] tokenNames = new String[] {
        "<invalid>", "<EOR>", "<DOWN>", "<UP>", "RULE_EMPTY", "RULE_ID", "RULE_CHAR", "RULE_UPCHAR", "RULE_UPID", "RULE_INT", "RULE_STRING", "RULE_ML_COMMENT", "RULE_SL_COMMENT", "RULE_WS", "RULE_ANY_OTHER", "','", "'('", "')'", "'/'", "'.'", "'.*'"
    };
    public static final int RULE_ID=5;
    public static final int RULE_UPCHAR=7;
    public static final int RULE_ANY_OTHER=14;
    public static final int T__20=20;
    public static final int EOF=-1;
    public static final int RULE_SL_COMMENT=12;
    public static final int RULE_ML_COMMENT=11;
    public static final int T__19=19;
    public static final int RULE_EMPTY=4;
    public static final int RULE_STRING=10;
    public static final int T__16=16;
    public static final int T__15=15;
    public static final int T__18=18;
    public static final int T__17=17;
    public static final int RULE_UPID=8;
    public static final int RULE_INT=9;
    public static final int RULE_CHAR=6;
    public static final int RULE_WS=13;

    // delegates
    // delegators


        public InternalCommonParser(TokenStream input) {
            this(input, new RecognizerSharedState());
        }
        public InternalCommonParser(TokenStream input, RecognizerSharedState state) {
            super(input, state);
             
        }
        

    public String[] getTokenNames() { return InternalCommonParser.tokenNames; }
    public String getGrammarFileName() { return "../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g"; }



     	private CommonGrammarAccess grammarAccess;
     	
        public InternalCommonParser(TokenStream input, CommonGrammarAccess grammarAccess) {
            this(input);
            this.grammarAccess = grammarAccess;
            registerRules(grammarAccess.getGrammar());
        }
        
        @Override
        protected String getFirstRuleName() {
        	return "Model";	
       	}
       	
       	@Override
       	protected CommonGrammarAccess getGrammarAccess() {
       		return grammarAccess;
       	}



    // $ANTLR start "entryRuleModel"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:67:1: entryRuleModel returns [EObject current=null] : iv_ruleModel= ruleModel EOF ;
    public final EObject entryRuleModel() throws RecognitionException {
        EObject current = null;

        EObject iv_ruleModel = null;


        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:68:2: (iv_ruleModel= ruleModel EOF )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:69:2: iv_ruleModel= ruleModel EOF
            {
             newCompositeNode(grammarAccess.getModelRule()); 
            pushFollow(FOLLOW_ruleModel_in_entryRuleModel75);
            iv_ruleModel=ruleModel();

            state._fsp--;

             current =iv_ruleModel; 
            match(input,EOF,FOLLOW_EOF_in_entryRuleModel85); 

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "entryRuleModel"


    // $ANTLR start "ruleModel"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:76:1: ruleModel returns [EObject current=null] : ( (lv_content_0_0= RULE_EMPTY ) ) ;
    public final EObject ruleModel() throws RecognitionException {
        EObject current = null;

        Token lv_content_0_0=null;

         enterRule(); 
            
        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:79:28: ( ( (lv_content_0_0= RULE_EMPTY ) ) )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:80:1: ( (lv_content_0_0= RULE_EMPTY ) )
            {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:80:1: ( (lv_content_0_0= RULE_EMPTY ) )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:81:1: (lv_content_0_0= RULE_EMPTY )
            {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:81:1: (lv_content_0_0= RULE_EMPTY )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:82:3: lv_content_0_0= RULE_EMPTY
            {
            lv_content_0_0=(Token)match(input,RULE_EMPTY,FOLLOW_RULE_EMPTY_in_ruleModel126); 

            			newLeafNode(lv_content_0_0, grammarAccess.getModelAccess().getContentEMPTYTerminalRuleCall_0()); 
            		

            	        if (current==null) {
            	            current = createModelElement(grammarAccess.getModelRule());
            	        }
                   		setWithLastConsumed(
                   			current, 
                   			"content",
                    		lv_content_0_0, 
                    		"EMPTY");
            	    

            }


            }


            }

             leaveRule(); 
        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "ruleModel"


    // $ANTLR start "entryRulePlainText"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:108:1: entryRulePlainText returns [String current=null] : iv_rulePlainText= rulePlainText EOF ;
    public final String entryRulePlainText() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_rulePlainText = null;


        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:109:2: (iv_rulePlainText= rulePlainText EOF )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:110:2: iv_rulePlainText= rulePlainText EOF
            {
             newCompositeNode(grammarAccess.getPlainTextRule()); 
            pushFollow(FOLLOW_rulePlainText_in_entryRulePlainText169);
            iv_rulePlainText=rulePlainText();

            state._fsp--;

             current =iv_rulePlainText.getText(); 
            match(input,EOF,FOLLOW_EOF_in_entryRulePlainText180); 

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "entryRulePlainText"


    // $ANTLR start "rulePlainText"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:117:1: rulePlainText returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )* ) ;
    public final AntlrDatatypeRuleToken rulePlainText() throws RecognitionException {
        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();

        Token this_ID_0=null;
        Token this_ID_1=null;
        Token kw=null;

         enterRule(); 
            
        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:120:28: ( (this_ID_0= RULE_ID (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )* ) )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:121:1: (this_ID_0= RULE_ID (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )* )
            {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:121:1: (this_ID_0= RULE_ID (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )* )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:121:6: this_ID_0= RULE_ID (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )*
            {
            this_ID_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_rulePlainText220); 

            		current.merge(this_ID_0);
                
             
                newLeafNode(this_ID_0, grammarAccess.getPlainTextAccess().getIDTerminalRuleCall_0()); 
                
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:128:1: (this_ID_1= RULE_ID | kw= ',' | kw= '(' | kw= ')' | kw= '/' )*
            loop1:
            do {
                int alt1=6;
                switch ( input.LA(1) ) {
                case RULE_ID:
                    {
                    alt1=1;
                    }
                    break;
                case 15:
                    {
                    alt1=2;
                    }
                    break;
                case 16:
                    {
                    alt1=3;
                    }
                    break;
                case 17:
                    {
                    alt1=4;
                    }
                    break;
                case 18:
                    {
                    alt1=5;
                    }
                    break;

                }

                switch (alt1) {
            	case 1 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:128:6: this_ID_1= RULE_ID
            	    {
            	    this_ID_1=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_rulePlainText241); 

            	    		current.merge(this_ID_1);
            	        
            	     
            	        newLeafNode(this_ID_1, grammarAccess.getPlainTextAccess().getIDTerminalRuleCall_1_0()); 
            	        

            	    }
            	    break;
            	case 2 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:137:2: kw= ','
            	    {
            	    kw=(Token)match(input,15,FOLLOW_15_in_rulePlainText265); 

            	            current.merge(kw);
            	            newLeafNode(kw, grammarAccess.getPlainTextAccess().getCommaKeyword_1_1()); 
            	        

            	    }
            	    break;
            	case 3 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:144:2: kw= '('
            	    {
            	    kw=(Token)match(input,16,FOLLOW_16_in_rulePlainText284); 

            	            current.merge(kw);
            	            newLeafNode(kw, grammarAccess.getPlainTextAccess().getLeftParenthesisKeyword_1_2()); 
            	        

            	    }
            	    break;
            	case 4 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:151:2: kw= ')'
            	    {
            	    kw=(Token)match(input,17,FOLLOW_17_in_rulePlainText303); 

            	            current.merge(kw);
            	            newLeafNode(kw, grammarAccess.getPlainTextAccess().getRightParenthesisKeyword_1_3()); 
            	        

            	    }
            	    break;
            	case 5 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:158:2: kw= '/'
            	    {
            	    kw=(Token)match(input,18,FOLLOW_18_in_rulePlainText322); 

            	            current.merge(kw);
            	            newLeafNode(kw, grammarAccess.getPlainTextAccess().getSolidusKeyword_1_4()); 
            	        

            	    }
            	    break;

            	default :
            	    break loop1;
                }
            } while (true);


            }


            }

             leaveRule(); 
        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "rulePlainText"


    // $ANTLR start "entryRuleQualifiedName"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:175:1: entryRuleQualifiedName returns [String current=null] : iv_ruleQualifiedName= ruleQualifiedName EOF ;
    public final String entryRuleQualifiedName() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleQualifiedName = null;


        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:176:2: (iv_ruleQualifiedName= ruleQualifiedName EOF )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:177:2: iv_ruleQualifiedName= ruleQualifiedName EOF
            {
             newCompositeNode(grammarAccess.getQualifiedNameRule()); 
            pushFollow(FOLLOW_ruleQualifiedName_in_entryRuleQualifiedName369);
            iv_ruleQualifiedName=ruleQualifiedName();

            state._fsp--;

             current =iv_ruleQualifiedName.getText(); 
            match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedName380); 

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "entryRuleQualifiedName"


    // $ANTLR start "ruleQualifiedName"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:184:1: ruleQualifiedName returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) ;
    public final AntlrDatatypeRuleToken ruleQualifiedName() throws RecognitionException {
        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();

        Token this_ID_0=null;
        Token kw=null;
        Token this_ID_2=null;

         enterRule(); 
            
        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:187:28: ( (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* ) )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:188:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
            {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:188:1: (this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )* )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:188:6: this_ID_0= RULE_ID (kw= '.' this_ID_2= RULE_ID )*
            {
            this_ID_0=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleQualifiedName420); 

            		current.merge(this_ID_0);
                
             
                newLeafNode(this_ID_0, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_0()); 
                
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:195:1: (kw= '.' this_ID_2= RULE_ID )*
            loop2:
            do {
                int alt2=2;
                int LA2_0 = input.LA(1);

                if ( (LA2_0==19) ) {
                    alt2=1;
                }


                switch (alt2) {
            	case 1 :
            	    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:196:2: kw= '.' this_ID_2= RULE_ID
            	    {
            	    kw=(Token)match(input,19,FOLLOW_19_in_ruleQualifiedName439); 

            	            current.merge(kw);
            	            newLeafNode(kw, grammarAccess.getQualifiedNameAccess().getFullStopKeyword_1_0()); 
            	        
            	    this_ID_2=(Token)match(input,RULE_ID,FOLLOW_RULE_ID_in_ruleQualifiedName454); 

            	    		current.merge(this_ID_2);
            	        
            	     
            	        newLeafNode(this_ID_2, grammarAccess.getQualifiedNameAccess().getIDTerminalRuleCall_1_1()); 
            	        

            	    }
            	    break;

            	default :
            	    break loop2;
                }
            } while (true);


            }


            }

             leaveRule(); 
        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "ruleQualifiedName"


    // $ANTLR start "entryRuleQualifiedNameWithWildcard"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:216:1: entryRuleQualifiedNameWithWildcard returns [String current=null] : iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF ;
    public final String entryRuleQualifiedNameWithWildcard() throws RecognitionException {
        String current = null;

        AntlrDatatypeRuleToken iv_ruleQualifiedNameWithWildcard = null;


        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:217:2: (iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:218:2: iv_ruleQualifiedNameWithWildcard= ruleQualifiedNameWithWildcard EOF
            {
             newCompositeNode(grammarAccess.getQualifiedNameWithWildcardRule()); 
            pushFollow(FOLLOW_ruleQualifiedNameWithWildcard_in_entryRuleQualifiedNameWithWildcard502);
            iv_ruleQualifiedNameWithWildcard=ruleQualifiedNameWithWildcard();

            state._fsp--;

             current =iv_ruleQualifiedNameWithWildcard.getText(); 
            match(input,EOF,FOLLOW_EOF_in_entryRuleQualifiedNameWithWildcard513); 

            }

        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "entryRuleQualifiedNameWithWildcard"


    // $ANTLR start "ruleQualifiedNameWithWildcard"
    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:225:1: ruleQualifiedNameWithWildcard returns [AntlrDatatypeRuleToken current=new AntlrDatatypeRuleToken()] : (this_QualifiedName_0= ruleQualifiedName (kw= '.*' )? ) ;
    public final AntlrDatatypeRuleToken ruleQualifiedNameWithWildcard() throws RecognitionException {
        AntlrDatatypeRuleToken current = new AntlrDatatypeRuleToken();

        Token kw=null;
        AntlrDatatypeRuleToken this_QualifiedName_0 = null;


         enterRule(); 
            
        try {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:228:28: ( (this_QualifiedName_0= ruleQualifiedName (kw= '.*' )? ) )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:229:1: (this_QualifiedName_0= ruleQualifiedName (kw= '.*' )? )
            {
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:229:1: (this_QualifiedName_0= ruleQualifiedName (kw= '.*' )? )
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:230:5: this_QualifiedName_0= ruleQualifiedName (kw= '.*' )?
            {
             
                    newCompositeNode(grammarAccess.getQualifiedNameWithWildcardAccess().getQualifiedNameParserRuleCall_0()); 
                
            pushFollow(FOLLOW_ruleQualifiedName_in_ruleQualifiedNameWithWildcard560);
            this_QualifiedName_0=ruleQualifiedName();

            state._fsp--;


            		current.merge(this_QualifiedName_0);
                
             
                    afterParserOrEnumRuleCall();
                
            // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:240:1: (kw= '.*' )?
            int alt3=2;
            int LA3_0 = input.LA(1);

            if ( (LA3_0==20) ) {
                alt3=1;
            }
            switch (alt3) {
                case 1 :
                    // ../sk.scerbak.ucl.common/src-gen/sk/scerbak/ucl/common/parser/antlr/internal/InternalCommon.g:241:2: kw= '.*'
                    {
                    kw=(Token)match(input,20,FOLLOW_20_in_ruleQualifiedNameWithWildcard579); 

                            current.merge(kw);
                            newLeafNode(kw, grammarAccess.getQualifiedNameWithWildcardAccess().getFullStopAsteriskKeyword_1()); 
                        

                    }
                    break;

            }


            }


            }

             leaveRule(); 
        }
         
            catch (RecognitionException re) { 
                recover(input,re); 
                appendSkippedTokens();
            } 
        finally {
        }
        return current;
    }
    // $ANTLR end "ruleQualifiedNameWithWildcard"

    // Delegated rules


 

    public static final BitSet FOLLOW_ruleModel_in_entryRuleModel75 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_entryRuleModel85 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RULE_EMPTY_in_ruleModel126 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_rulePlainText_in_entryRulePlainText169 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_entryRulePlainText180 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RULE_ID_in_rulePlainText220 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_RULE_ID_in_rulePlainText241 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_15_in_rulePlainText265 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_16_in_rulePlainText284 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_17_in_rulePlainText303 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_18_in_rulePlainText322 = new BitSet(new long[]{0x0000000000078022L});
    public static final BitSet FOLLOW_ruleQualifiedName_in_entryRuleQualifiedName369 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_entryRuleQualifiedName380 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_RULE_ID_in_ruleQualifiedName420 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_19_in_ruleQualifiedName439 = new BitSet(new long[]{0x0000000000000020L});
    public static final BitSet FOLLOW_RULE_ID_in_ruleQualifiedName454 = new BitSet(new long[]{0x0000000000080002L});
    public static final BitSet FOLLOW_ruleQualifiedNameWithWildcard_in_entryRuleQualifiedNameWithWildcard502 = new BitSet(new long[]{0x0000000000000000L});
    public static final BitSet FOLLOW_EOF_in_entryRuleQualifiedNameWithWildcard513 = new BitSet(new long[]{0x0000000000000002L});
    public static final BitSet FOLLOW_ruleQualifiedName_in_ruleQualifiedNameWithWildcard560 = new BitSet(new long[]{0x0000000000100002L});
    public static final BitSet FOLLOW_20_in_ruleQualifiedNameWithWildcard579 = new BitSet(new long[]{0x0000000000000002L});

}